// 增强版 - 测试通义千问模型返回HTML格式的问题
const AiModelService = require('./src/services/aiModelService');
const fs = require('fs');
const path = require('path');
const axios = require('axios');

// 简单的测试文本
const testContent = `
Node.js是一个基于Chrome V8引擎的JavaScript运行环境。
Node.js使用了一个事件驱动、非阻塞式I/O的模型，使其轻量又高效。
Node.js的包管理器npm，是全球最大的开源库生态系统。

主要特点：
1. 非阻塞I/O
2. 事件驱动
3. 轻量高效
4. 单线程
5. 跨平台

Node.js适合开发需要处理大量并发连接但计算强度不高的应用，如聊天服务器、API服务等。
`;

// 辅助函数：检测HTML内容
function detectHtml(text) {
  // 检查常见的HTML标签
  const htmlTagPattern = /<\/?[a-z][\s\S]*?>/i;
  
  // 检查HTML实体
  const htmlEntityPattern = /&[a-z]+;|&#[0-9]+;/i;
  
  // 检查DOCTYPE声明
  const doctypePattern = /<!DOCTYPE\s+html>/i;
  
  // 检查整体HTML结构
  const htmlStructurePattern = /<html[\s\S]*?<\/html>/i;
  
  return {
    hasHtmlTags: htmlTagPattern.test(text),
    hasHtmlEntities: htmlEntityPattern.test(text),
    hasDoctype: doctypePattern.test(text),
    hasHtmlStructure: htmlStructurePattern.test(text),
    isHtml: htmlTagPattern.test(text) || htmlEntityPattern.test(text) || doctypePattern.test(text) || htmlStructurePattern.test(text)
  };
}

// 辅助函数：提取HTML中的JSON
function extractJsonFromHtml(htmlContent) {
  // 尝试查找JSON块
  const jsonBlockPattern = /\[\s*\{[\s\S]*?\}\s*\]/g;
  const jsonMatches = htmlContent.match(jsonBlockPattern);
  
  if (jsonMatches && jsonMatches.length > 0) {
    try {
      // 尝试解析找到的第一个JSON块
      return JSON.parse(jsonMatches[0]);
    } catch (e) {
      console.log('从HTML中提取的JSON块解析失败:', e.message);
    }
  }
  
  // 如果没有找到JSON块，尝试寻找pre标签中的内容
  const preContentPattern = /<pre[^>]*>([\s\S]*?)<\/pre>/i;
  const preMatch = htmlContent.match(preContentPattern);
  
  if (preMatch && preMatch[1]) {
    try {
      // 尝试解析pre标签中的内容
      return JSON.parse(preMatch[1]);
    } catch (e) {
      console.log('从pre标签中提取的内容解析JSON失败:', e.message);
    }
  }
  
  // 如果以上方法都失败，尝试提取所有的文本内容
  const textContent = htmlContent.replace(/<[^>]*>/g, '');
  
  // 在纯文本中查找JSON格式
  const jsonInTextPattern = /\[\s*\{[\s\S]*?\}\s*\]/g;
  const textJsonMatches = textContent.match(jsonInTextPattern);
  
  if (textJsonMatches && textJsonMatches.length > 0) {
    try {
      // 尝试解析找到的第一个JSON块
      return JSON.parse(textJsonMatches[0]);
    } catch (e) {
      console.log('从纯文本中提取的JSON块解析失败:', e.message);
    }
  }
  
  return null;
}

// 辅助函数：移除HTML标签
function stripHtml(html) {
  return html.replace(/<[^>]*>/g, '');
}

// 测试不同的提示词，看哪个能有效防止HTML响应
const prompts = [
  { 
    name: "默认提示词", 
    prompt: `请分析以下内容，生成知识卡片。返回JSON格式，不要返回HTML。` 
  },
  { 
    name: "明确指定JSON格式", 
    prompt: `请分析以下内容，生成知识卡片。必须返回有效的JSON格式数组，每个卡片包含title、content和tags字段。不要返回HTML或Markdown，只返回纯文本JSON。` 
  },
  { 
    name: "强调纯文本返回", 
    prompt: `请分析以下内容，生成知识卡片。返回纯文本JSON数组，格式如下：[{"title":"标题","content":"内容","tags":["标签1","标签2"]}]。严禁返回HTML或任何标记语言格式。` 
  },
  { 
    name: "使用代码块格式", 
    prompt: `请分析以下内容，生成知识卡片。将结果作为JSON数组返回，格式如下：
\`\`\`json
[
  {"title":"标题1","content":"内容1","tags":["标签1","标签2"]},
  {"title":"标题2","content":"内容2","tags":["标签3","标签4"]}
]
\`\`\`
不要返回HTML或其他格式，只返回上述JSON格式。` 
  }
];

// 主测试函数
async function testQwenResponse() {
  try {
    console.log('='.repeat(80));
    console.log('测试通义千问模型返回格式问题 - 增强版');
    console.log('='.repeat(80));
    console.log('发送测试内容:', testContent.substring(0, 100) + '...');
    
    // 测试每个提示词
    for (const promptConfig of prompts) {
      console.log('\n' + '-'.repeat(80));
      console.log(`测试提示词: ${promptConfig.name}`);
      console.log('-'.repeat(80));
      
      try {
        // 调用通义千问模型
        const response = await AiModelService.parseWithQwenLong(testContent, {
          task: 'generate_cards',
          temperature: 0.3,
          max_tokens: 1000,
          customPrompt: promptConfig.prompt
        });
        
        // 打印原始响应
        console.log('\n原始响应:');
        console.log('成功状态:', response.success);
        
        // 检查是否为HTML
        const htmlDetection = detectHtml(response.result);
        console.log('\nHTML检测结果:');
        console.log('- 包含HTML标签:', htmlDetection.hasHtmlTags);
        console.log('- 包含HTML实体:', htmlDetection.hasHtmlEntities);
        console.log('- 包含DOCTYPE声明:', htmlDetection.hasDoctype);
        console.log('- 包含HTML结构:', htmlDetection.hasHtmlStructure);
        console.log('- 总体判断为HTML:', htmlDetection.isHtml);
        
        // 如果检测到HTML，尝试提取JSON
        if (htmlDetection.isHtml) {
          console.log('\n检测到HTML格式响应，尝试提取JSON...');
          const extractedJson = extractJsonFromHtml(response.result);
          if (extractedJson) {
            console.log('成功从HTML中提取JSON数据:');
            console.log(JSON.stringify(extractedJson, null, 2).substring(0, 300) + '...');
          } else {
            console.log('无法从HTML中提取JSON数据');
            console.log('HTML内容预览:', stripHtml(response.result).substring(0, 300) + '...');
          }
        } else {
          // 尝试解析JSON
          try {
            const jsonData = JSON.parse(response.result);
            console.log('\n成功解析为JSON:');
            console.log(JSON.stringify(jsonData, null, 2).substring(0, 300) + '...');
          } catch (error) {
            console.log('\n解析JSON失败:', error.message);
            console.log('原始内容预览:', response.result.substring(0, 300) + '...');
          }
        }
        
        // 保存响应到文件
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
        const filename = `qwen-response-${promptConfig.name}-${timestamp}.txt`;
        const filepath = path.join(__dirname, filename);
        fs.writeFileSync(filepath, response.result);
        console.log(`\n响应已保存到文件: ${filename}`);
        
      } catch (error) {
        console.error(`使用提示词 "${promptConfig.name}" 测试失败:`, error);
        if (error.response) {
          console.error('API响应状态码:', error.response.status);
          console.error('API响应头:', JSON.stringify(error.response.headers, null, 2));
          console.error('API响应数据:', JSON.stringify(error.response.data, null, 2));
        }
      }
    }
    
    console.log('\n' + '='.repeat(80));
    console.log('测试完成');
    console.log('='.repeat(80));
    
  } catch (error) {
    console.error('测试过程中发生错误:', error);
    console.error('错误堆栈:', error.stack);
  }
}

// 运行测试
testQwenResponse(); 